﻿using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Input;
using personalplaner.business.extensions;
using personalplaner.business.stamm;
using personalplaner.common.mvvm;
using personalplaner.common.mvvm.commands;
using personalplaner.common.mvvm.common;
using personalplaner.servicemodel.dataaccess;
using personalplaner.gui.common;
using personalplaner.business;


namespace personalplaner.gui.stamm.viewmodels
{
    public class AnstellungsStammViewModel : BaseViewModel
    {
        public AnstellungsStammViewModel(DependencyObject parent)
            : base(parent)
        {
        }

		public override void Loaded()
		{
			var mw = GetService<IMainWindowDisplayContainer>();
			mw.IsWaitVisible = false;
		}

        #region Commands

        ICommand _okcommand;
        public ICommand OkCommand
        {
            get
            {
                if (_okcommand == null)
                    _okcommand = new RelayCommand(OnOkCommand);
                return _okcommand;
            }
        }

        private void OnOkCommand(object parameter)
        {
			var wnd = Parent as Window;
			if (wnd != null)
			{
				wnd.DialogResult = true;
				wnd.Close();
				return;
			}

			var mw = GetService<IMainWindowDisplayContainer>();
			mw.MoveToPreviousView();
        }

        ICommand _cancelcommand;
        public ICommand CancelCommand
        {
            get
            {
                if (_cancelcommand == null)
                    _cancelcommand = new RelayCommand(OnCancelCommand);
                return _cancelcommand;
            }
        }

        private void OnCancelCommand(object parameter)
        {
			var wnd = Parent as Window;
			if (wnd != null)
			{
				wnd.DialogResult = false;
				wnd.Close();
				return;
			}

			var mw = GetService<IMainWindowDisplayContainer>();
			mw.MoveToPreviousView();
        }

        ICommand _savecommand;
        public ICommand SaveCommand
        {
            get
            {
                if (_savecommand == null)
                    _savecommand = new RelayCommand(OnSave, parameter => SelectedAnstellung != null && SelectedAnstellung.IsValid);
                return _savecommand;
            }
        }

        private void OnSave(object parameter)
        {
			if (SelectedAnstellung == null || !SelectedAnstellung.IsValid)
			{
				MessageBox.Show(Window.GetWindow(Parent),
					"Bitte füllen Sie alle Felder aus.",
					"",
					MessageBoxButton.OK,
					MessageBoxImage.Exclamation);
				return;
			}

			//Update
			if (!SelectedAnstellung.IsNew)
			{
				var da = GetService<IAnstellungDataAccess>();
				if (!da.UpdateAnstellung(SelectedAnstellung))
				{
					MessageBox.Show(Window.GetWindow(Parent),
									string.Format("Beim Speichern der Anstellung : {0} ist ein Fehler aufgetreten!", SelectedAnstellung.Name),
									"Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
					return;
				}
			}
			else
			{
				var da = GetService<IAnstellungDataAccess>();
				if (!da.SetAnstellung(SelectedAnstellung))
				{
					MessageBox.Show(Window.GetWindow(Parent),
									string.Format("Beim Speichern der Anstellung : {0} ist ein Fehler aufgetreten!", SelectedAnstellung.Name),
									"Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
					return;
				}

				Anstellungen.Add(SelectedAnstellung);
			}

			for (int i = 0; i < Anstellungen.Count; i++)
			{
				if (Anstellungen[i].AnstellungID == SelectedAnstellung.AnstellungID)
				{
					Anstellungen[i] = SelectedAnstellung;
					ActiveGridItem = SelectedAnstellung;
					break;
				}
			}
        }

        ICommand _newcommand;
        public ICommand NewCommand
        {
            get
            {
                if (_newcommand == null)
                    _newcommand = new RelayCommand(OnNew);
                return _newcommand;
            }
        }

        private void OnNew(object parameter)
        {
            ActiveGridItem = null;
            SelectedAnstellung = new Anstellung();
        }

		ICommand _deleteCommand;
		public ICommand DeleteCommand
        {
            get
            {
				if (_deleteCommand == null)
					_deleteCommand = new RelayCommand(OnDelete, param => SelectedAnstellung != null && !SelectedAnstellung.IsNew);
				return _deleteCommand;
            }
        }

		private void OnDelete(object parameter)
		{
            if (SelectedAnstellung.IsNew)
            {
                MessageBox.Show("Die Anstellung kann nicht gelöscht werden da diese noch nicht existiert!", "",
                                MessageBoxButton.OK);
                return;
            }

            var da = GetService<IAnstellungDataAccess>();
            if (da.GetIsAnstellungUsed(SelectedAnstellung.AnstellungID))
            {
                MessageBox.Show(Window.GetWindow(Parent),
                                "Die Anstellung kann nicht gelöscht werden da diese bereits in einem Plan verwendet wird.",
                                "Anstellung löschen",
                                MessageBoxButton.OK,
                                MessageBoxImage.Asterisk);
                return;
            }

            if (MessageBox.Show(Window.GetWindow(Parent),
                                string.Format("Sind Sie sicher dass Sie die Anstellung:\n{0}\nlöschen möchten?", SelectedAnstellung.Name),
                                "Anstellung löschen?",
                                MessageBoxButton.OKCancel) == MessageBoxResult.OK)
            {
                if (!da.DeleteAnstellung(SelectedAnstellung.AnstellungID))
                {
                    MessageBox.Show(Window.GetWindow(Parent), string.Format("Die Anstellung : {0} konnte nicht gelöscht werden!", SelectedAnstellung.Name), "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                SelectedAnstellung = null;
                ActiveGridItem = null;
                Anstellungen = null;
            }
		}



    	#endregion

        #region Properties

        IList<Anstellung> _Anstellungen;
        public IList<Anstellung> Anstellungen
        {
            get
            {
                if (Designer.IsDesignMode)
                    return new List<Anstellung>();

                if (_Anstellungen == null)
                {
                    //get the data access via the service locator.
                    var da = GetService<IAnstellungDataAccess>();
					var lst = da.GetAnstellungen();
					_Anstellungen = lst != null ? new ObservableCollection<Anstellung>(lst) : new ObservableCollection<Anstellung>();
                }
                return _Anstellungen;
            }
			set
			{
				_Anstellungen = value;
				RaisePropertyChanged("Anstellungen");
			}
        }

        Anstellung _activegriditem;
        public Anstellung ActiveGridItem
        {
            get
            {
                return _activegriditem;
            }
            set
            {
                _activegriditem = value;
                RaisePropertyChanged("ActiveGridItem");

                if (value == null)
                {
                    SelectedAnstellung = null;
                    return;
                }

                SelectedAnstellung = value.Clone<Anstellung>();
            }
        }

        Anstellung _selectedAnstellung;
        public Anstellung SelectedAnstellung
        {
            get
            {
                return _selectedAnstellung;
            }
            set
            {
                _selectedAnstellung = value;
                RaisePropertyChanged("SelectedAnstellung");
                RaisePropertyChanged("IsEditEnabled");
            }
        }

        public bool IsEditEnabled
        {
            get
            {
                return SelectedAnstellung != null;
            }
        }

        #endregion
    }
}
